// var StoreWH = require("./aofei/StoreWH.js");
// var HttpWH = require("./aofei/HttpWH.js");
var StoreWH = require("/sdcard/脚本/QQ阅读助手/QQ阅读助手/aofei/StoreWH.js");
var HttpWH = require("/sdcard/脚本/QQ阅读助手/QQ阅读助手/aofei/HttpWH.js");

engines.execScriptFile("/sdcard/脚本/QQ阅读助手/QQ阅读助手/aofei/permit.js")
toastLog("开始请求截图权限")
if (!requestScreenCapture()) {
    toastLog("请求截图权限失败！");
    alert("请求截图权限失败！")
} else {
    toastLog("请求截图权限成功~")
}

// 参数定义
homeFlag = desc("书架") //首页标志

maxReadTime = 0 //最大阅读时长(分钟)
readTimeCount = 0 //账号累计阅读时长(分钟)
isMaxRead = false //是否触发最大阅读时长
readCyclic = 1 //累计阅读时长的循环周期(分钟)

CAccounts = [] //任务完成账号列表
account = ""
isTaskAllFinish = false //全部账号任务是否完成

tBooks = [] //阅读列表
cBooks = [] //书架已阅读书籍
isSJBottom = false //是否已阅读到书架底部
isListMode = false //是否切换列表模式
sjTaskisok = false
bzqtTaskisok = false
sjTryNum = 99
qtTryNum = 10 //强推
qlTryNum = 10 //潜力
goBranchTryNum = 5

deviceID = ""
bookID = ""

homeFlag = desc("书架")

ywAccounts = []



// *** 公用方法 ***
// 进入目标页
function goPage(name) {


    let tryNum = 3
    while (tryNum--) {
        if (currentPackage() != app.getPackageName("QQ阅读")) {
            //允许权限
            engines.execScriptFile("/sdcard/脚本/QQ阅读助手/QQ阅读助手/aofei/permit.js")
            toastLog("启动应用");
            app.launchApp("QQ阅读")

            // 跳过广告
            obj = textContains("跳过").findOne(5000)
            if (obj) {
                toastLog("跳过广告")
                obj.click()
                sleep(2000)
            }

            homeFlag.findOne(10000)
            sleep(5000)

            // 关闭各种弹窗
            closeDialogs()
        }

        // 返回首页
        let tryNum2 = 3
        while (!homeFlag.exists() && tryNum2--) {
            toastLog("返回上级")
            back()
            onClick(text("退出"), "退出应用")
        }

        // 切换页面
        if (switchPage(name)) break
    }
}
// 切换页面
function switchPage(name) {
    let flag = desc(name)
    let flag2 = desc(name).className("android.view.View")
    if (name == "书架") {
        obj = flag2.findOnce()
        obj = obj ? obj : flag.findOnce()
    } else {
        obj = flag.findOnce()
    }

    return onClick(obj, "进入：[" + name + "]", 1, 10000)
}

// 进入目标分支页
function goBranch(name, flag, type) {
    // 寻找目标入口
    let tryNum = goBranchTryNum
    while (tryNum--) {
        obj = desc(name).findOne(3000)
        if (obj) {
            if (!type) {
                // obj2 = obj.parent().find(!flag ? desc("更多") : flag)
                obj2 = obj.find(!flag ? desc("更多") : flag)
                if (obj2.length == 1) {
                    toastLog("进入目标分支页：" + name)
                    obj2[0].click()
                    sleep(3000)
                    return true
                }
            } else {
                toastLog("已找到入口，滑动屏幕加载更多内容")
                swipeY2()
                swipeY2()
                swipeY2()
                sleep(3000)
                return true
            }
        }

        toastLog("正在寻找分支入口[" + tryNum + "]")
        swipeY()
        sleep(3000)
    }
}

// 关闭各种弹窗
function closeDialogs() {
    toastLog("请稍等，正在判断是否存在对话框..")
    while (true) {
        if (
            !onClick(text("我知道了"), "关闭青少年提醒", 0, 0, 1000)
            && !onClick(idMatches(/.*close.*|.*cancel.*/), "关闭弹窗", 0, 0, 1000)
            && !onClick(text("暂不开启"), "暂不开启", 0, 0, 1000)
            && !onClick(desc("暂不开启"), "暂不开启2", 0, 0, 1000)
        ) {
            break;
        }
    }
}

// 查找并调用对象点击事件
function onClick(obj, msg, type, sTime, fTime) {
    if (!type) {
        obj = obj.findOne(fTime ? fTime : 2000)
    }
    if (obj) {
        if (msg) toastLog(msg)
        // if (msg) setPushLog(msg)
        obj.click()
        sleep(sTime ? sTime : 2000)
        return true
    }
}
function whileonClick(obj, msg, type, sTime, fTime) {
    while (true) {
        if (!onClick(obj, msg, type, sTime, fTime)) {
            break;
        }
    }
}
// 查找并调用对象1级父类的点击事件
function onParentClick(obj, msg) {
    obj = obj.findOne(3000)
    if (obj) {
        if (msg) toastLog(msg)
        obj.parent().click()
        sleep(2000)
        return true
    }
}

// 查找并调用对象3级父类的点击事件
function onParent3Click(obj, msg) {
    obj = obj.findOne(3000)
    if (obj) {
        toastLog(msg)
        obj.parent().parent().parent().click()
        sleep(2000)
        return true
    }
}

// 上下滑屏(翻页)
function swipeY(reverse) {
    let w = device.width
    let h = device.height

    let x_array = [{
        x1: 0.5,
        x2: 0.6
    }, {
        x1: 0.6,
        x2: 0.7
    }, {
        x1: 0.7,
        x2: 0.8
    }]
    let y_array = !reverse ? [{
        y1: 0.6,
        y2: 0
    }, {
        y1: 0.7,
        y2: 0.1
    }] : [{
        y1: 0.4,
        y2: 1
    }, {
        y1: 0.3,
        y2: 0.9
    }]

    let x_r = random(0, x_array.length - 1)
    let y_r = random(0, y_array.length - 1)
    let t_r = random(6, 12)

    swipe(w * x_array[x_r].x1, h * y_array[y_r].y1, w * x_array[x_r].x2, h * y_array[y_r].y2, t_r * 100)
}

// 上下滑屏(短距离)
function swipeY2(reverse) {
    let w = device.width
    let h = device.height

    let x_array = [{
        x1: 0.5,
        x2: 0.6
    }, {
        x1: 0.6,
        x2: 0.7
    }, {
        x1: 0.7,
        x2: 0.8
    }]
    let y_array = !reverse ? [{
        y1: 0.5,
        y2: 0.3
    }, {
        y1: 0.7,
        y2: 0.5
    }] : [{
        y1: 0.3,
        y2: 0.5
    }, {
        y1: 0.5,
        y2: 0.7
    }]

    let x_r = random(0, x_array.length - 1)
    let y_r = random(0, y_array.length - 1)
    let t_r = random(6, 12)

    swipe(w * x_array[x_r].x1, h * y_array[y_r].y1, w * x_array[x_r].x2, h * y_array[y_r].y2, t_r * 100)
}

// 随机休息-秒
function RSleep(p1, p2, type) {
    let num = random(p1, p2)
    let time = 0

    if (!type) {
        toastLog("[随机休息]：" + num + "秒")
        time = num * 1000
    } else {
        toastLog("[随机休息]：" + num + "分钟")
        time = num * 1000 * 60
    }
    sleep(time)
}

//===========================================================================_________________________________________

// 获取不重复数据
function getOnlyOne(ywAccounts, CAccounts) {
    let temp = []
    for (let i = 0; i < ywAccounts.length; i++) {
        let item = ywAccounts[i]
        if (!CAccounts.includes(item.account)) {
            temp.push(item)
        }
    }
    return temp
}

//数据重置
function resetData() {
    isMaxRead = false
    cBooks = []
    isSJBottom = false
    sjTaskisok = false;
    bzqtTaskisok = false;
}

// 切换账号
function switchAccount() {
    // 提示
    toastLog("开始执行：[切换账号任务]")
    sleep(2000)

    // 进入目标页
    goPage("我的")

    // 进入设置页 退出登录
    obj = descContains("IP属地").findOne(3000)
    if (obj) {
        onClick(obj.parent().parent().child(1), "进入设置页", 1)

        // 滑动设置页到底部
        let tryNum = 10
        while (tryNum--) {
            // 判断是否到页面底部
            if (text("退出登录").exists()) {
                toastLog("已到页面底部")
                sleep(1000)
                break
            }

            toastLog("滑动页面")
            swipeY()
            sleep(1000)
        }

        //退出登录
        onParentClick(text("退出登录"), "退出登录")
        onClick(text("退出"), "确认退出")
    }

    // 阅文账号登录
    if (ywAccounts.length > 0) {
        //尝试再次登录
        if (!onClick(descContains("账号登录"), "再次阅文登录")) {
            if (!onClick(descContains("登录方式"), "尚未登录")) {
                whileonClick(descContains("立即登录"), "正在登录")
            }
            // 选择登录方式
            whileonClick(descContains("登录方式"), "选择登录方式")
            whileonClick(textContains("登录方式"), "选择登录方式")
            //选择阅文登录
            whileonClick(idContains("login_qidian"), "选择阅文登录", 0, 0, 20000)
        }

        // 同意协议
        whileonClick(text("同意"), "同意协议")

        // 填写账号
        obj = idContains("NameEdit").findOne(20000) //等待加载
        if (!obj) {
            toastLog("未找到账号输入框，登录失败！")
            return false
        }
        sleep(1000)
        account = ywAccounts[0].account
        pwd = ywAccounts[0].password
        toastLog("填写账号：[" + account + "] 密码：[" + pwd + "]")
        idContains("NameEdit").setText(account)
        idContains("PwdEdit").setText(pwd)
        ywAccounts.splice(0, 1) //删除已登录账号
        log("剩余阅文账号：" + JSON.stringify(ywAccounts))
        // 判断是否全部完成
        if (!ywAccounts.length) isTaskAllFinish = true

        // 登录
        if (onClick(idContains("LoginText"), "确认登录", 0, 10000)) {
            if (text("关闭验证").findOne(10000)) {

                let tryNum = 5
                while (tryNum--) {
                    //允许权限

                    toastLog("发现滑块验证码，现在开始识别，请稍等..[" + tryNum + "]")

                    var src = captureScreen();
                    var clip = images.clip(src, 0, device.height * 0.3, device.width, device.height * 0.7)
                    var xjsyzm = http.post("https://xiongjs.plus/ManageOCR/Universal.php", { // { Results: true, center: 230, author: 9960 }
                        "name": "So78hpBSpDEpH",
                        "itemID": "allRoundSlider",
                        "Imgview": images.toBase64(clip)
                    }).body.json();
                    console.log(xjsyzm);

                    if (xjsyzm.code || xjsyzm.Results) {
                        // log("坐标：", xjsyzm.center);
                        let temp = xjsyzm.center
                        log("获取坐标成功：" + temp)

                        // 滑动
                        toastLog("开始滑动~")
                        if (device.height == 2400) {
                            swipe(250, 1473, xjsyzm.center, 1473, 1000) //1080*2400
                        }

                        if (device.height == 2160) {
                            swipe(250, 1333, xjsyzm.center, 1333, 1000) //1080*2160
                        }

                        if (device.height == 2160) {
                            swipe(244, 1400, xjsyzm.center, 1333, 1862) //1080*2160
                        }

                        sleep(3000)
                        if (!text("关闭验证").exists()) {
                            toastLog("验证成功！")
                            break
                        }
                    } else {
                        alert("接口调用失败提示", xjsyzm.message ? xjsyzm.message : "未知错误！")
                        return false
                    }
                }

                // 判断是否通过验证
                if (!homeFlag.findOne(10000)) return false
            }
            return true
        }
    }

    //尝试再次登录
    if (!onClick(descContains("QQ登录"), "再次QQ登录")) {
        //选择登录方式
        onClick(descContains("登录方式"), "选择登录方式")
        //选择QQ登录
        onClick(idContains("login_qq"), "选择QQ登录", 0, 0, 20000)
    }

    // 同意协议
    onClick(text("同意"), "同意协议")

    // 切换账号
    onClick(text("切换账号"), "切换账号", 0, 0, 20000)

    // 获取已完成账号列表
    CAccounts = StoreWH.getCAccounts()
    // CAccounts = ['416271606', '485205975']
    log("已完成账号：[" + CAccounts + "]")

    // 获取当前全部账号，选择一个未完成账号进行登录
    flag = className("com.tencent.mobileqq.widget.listitem.QUIDoubleLineListItem")
    flag.findOne(10000)
    obj = flag.find()
    if (obj.length > 0) {
        for (let i = 0; i < obj.length; i++) {
            obj2 = obj[i].child(0).child(1).child(1).text()
            // log(obj2)
            if (!CAccounts.includes(obj2)) {
                account = obj2

                // 判断是否全部完成
                if (i == obj.length - 1) isTaskAllFinish = true
                break
            }
        }
    } else {
        log("未找到QQ账号，请检查再重试！")
        return false
    }

    // 选择账号
    toastLog("切换账号：[" + account + "]")
    onParent3Click(text(account), "选择账号")

    // 同意登录
    if (onClick(text("同意"), "同意登录", 0, 10000))
        return true
}

// 潜力新书任务
function qlxsTask() {
    // 提示
    toastLog("执行任务：[从潜力新书阅读指定书籍]")
    sleep(2000)

    // 阅读指定书籍
    let tryNum = qlTryNum
    while (tryNum--) {
        //进入目标页
        goPage("书城")

        // 找到目标分支
        if (!goBranch("潜力新书", null, 1)) {
            toastLog("未找到潜力新书入口！")
            sleep(2000)
            return
        }

        // 阅读当前存在的指定书籍
        readBook()

        // 是否阅读超时
        if (isMaxRead) {
            toastLog("账号：[" + account + "]已达到最大阅读时长，不再阅读书籍")
            sleep(2000)
            break
        }

        // 判断是否已阅读完成
        if (tBooks.length == 0) {
            toastLog("指定书籍已阅读完成！")
            sleep(2000)
            break
        }

        // 提示
        toastLog("潜力找书剩余次数：" + tryNum)
        sleep(2000)
    }
}

// 本周强推任务
function bzqtTask() {
    // 提示
    toastLog("执行任务：[从本周强推阅读指定书籍]")
    sleep(2000)

    //进入目标页
    goPage("书城")
    goPage("书城")

    // 进入本周强推
    if (!goBranch("本周强推")) {
        toastLog("未找到本周强推入口！")
        sleep(2000)
        return
    }

    // 阅读指定强推书籍
    let tryNum = qtTryNum
    while (tryNum--) {
        let tryNum2 = 30
        while (tryNum2--) {
            // 阅读当前存在的指定书籍
            readBook()

            // 是否阅读超时
            if (isMaxRead) {
                toastLog("账号：[" + account + "]已达到最大阅读时长，不再阅读书籍")
                sleep(2000)
                break
            }

            // 判断是否已阅读完成
            if (tBooks.length == 0) {
                toastLog("指定书籍已阅读完成！")
                sleep(2000)
                break
            }

            if (desc("已显示全部").exists()) {
                toastLog("当前页未找到指定小说，刷新页面")
                back()
                sleep(2000)

                // 进入本周强推
                goBranch("本周强推")
                break
            }

            toastLog("正在寻找指定书籍[" + tryNum + "]")
            swipeY()
            sleep(3000)
        }
    }

    // 返回上级
    let tryNum2 = 3
    while (!descMatches(/书架/).exists() && tryNum2--) {
        toastLog("返回上级")
        back()
        sleep(2000)
    }
}

// 书架任务
function sjTask() {
    // 提示
    toastLog("执行任务：[从书架阅读指定书籍]")
    sleep(2000)

    let tryNum2 = 4
    while (tryNum2--) {
        log("书架找书.." + tryNum2)

        //进入目标页
        goPage("书架")

        // 切换列表模式
        if (!isListMode) {
            // 打开菜单
            obj = desc("书架").findOne(3000)
            if (obj) {
                onClick(obj.parent().child(3), "打开菜单", 1, 1000)
            }

            // 切换列表模式
            if (!onClick(desc("列表模式"), "切换列表模式")) click(device.width / 2, device.height * 0.7)
            isListMode = true
            sleep(3000)
        }

        // 阅读指定书籍
        let tryNum = sjTryNum
        while (tryNum--) {
            //书架为空
            if (desc("空空如也").exists()) {
                toastLog("书架为空")
                sleep(2000)
                return
            }

            // 阅读当前存在的指定书籍
            readBook()

            // 是否阅读超时
            if (isMaxRead) {
                toastLog("账号：[" + account + "]已达到最大阅读时长，不再阅读书籍")
                sleep(2000)
                return
            }

            // 判断是否已阅读完成
            if (tBooks.length == 0) {
                toastLog("指定书籍已阅读完成！")
                sjTaskisok = true;
                sleep(2000)
                return
            }

            // 判断是否已阅读到书架底部
            if (desc("更多精彩小说").exists()) {
                toastLog("已到书架底部")
                sleep(2000)
                break
            }

            toastLog("正在寻找指定书籍[" + tryNum + "]")
            swipeY()
            sleep(3000)
        }
    }
}

// 阅读当前存在的指定书籍
function readBook() {
    // 遍历查找
    for (let i = 0; i < tBooks.length; i++) {
        bookTitle = tBooks[i].book_title
        bookID = tBooks[i].book_id
        log("寻找书籍：" + bookTitle)
        flag = descContains(bookTitle).findOnce()
        if (flag) {
            setPushLog("进入指定小说：[" + bookTitle + "]")
            flag.click()//不要whileonclcik吗？
            sleep(10000)

            // onClick(desc("加书架"), "加入书架", 0, 0, 5000)
            whileonClick(desc("加书架"), "加入书架", 0, 0, 5000)

            // onClick(descMatches(/.*(试|阅)读/), "进入阅读页面")
            whileonClick(descMatches(/.*(试|阅)读/), "进入阅读页面")

            // 开始阅读
            startRead()

            let tryNum2 = 9
            while (!descMatches(/本周强推|书架/).exists() && tryNum2--) {
                toastLog("返回上级")
                back()
                sleep(2000)
            }

            //删除已读书籍元素
            tBooks.splice(i, 1)
            setPushLog("剩余指定阅读书籍：[" + getBookNames(tBooks) + "]")
            sleep(2000)
        }
    }
}

// 开启自动阅读
function autoRead() {
    while (true) {
        if (!text("设置").exists()) {
            click(device.width / 2, device.height * 0.1 * random(5, 7))
            sleep(2000);
            sleep(1985);
        } else {
            break;
        }
    }
    // onClick(text("设置"), "进入设置")
    // onClick(text("自动阅读"), "开始阅读")
    while (true) {
        if (!onClick(text("自动阅读"), "开始阅读")) {
            onClick(text("设置"), "进入设置")
        } else {
            break;
        }
        sleep(1985);
        sleep(666);
    }
    whileonClick(text("自动阅读"), "开始阅读")
}

// 开始阅读
function startRead() {
    // 关闭内容更新提示
    // onClick(text("确认"), "确认更新内容")
    whileonClick(text("确认"), "确认更新内容")

    setPushLog("开启自动阅读")
    autoRead()

    // 阅读时长累计循环
    setPushLog("开启阅读时长累计循环，循环周期为：" + readCyclic + "分钟")
    sleep(2000)
    let tryNum = 300
    while (true) {
        // 判断阅读累计时长是否达到最大阈值
        if (readTimeCount >= maxReadTime) {
            setPushLog("账号：[" + account + "]已达到最大阅读时长！")
            isMaxRead = true
            break
        }

        // 最新章节阅读结束
        if (text("作者努力码字中～").exists()) {
            setPushLog("当前书籍最新章节已阅读完成！")
            break
        }
        if (id("com.qq.reader:id/tv_complete_achievement").exists()) {
            setPushLog("当前书籍最新章节已阅读完成！")
            break
        }
        // 整本书籍阅读完成
        if (text("全书完").exists()) {
            setPushLog("当前书籍已全部阅读完成！")
            break
        }

        // 会员内容停止阅读
        if (textMatches(/.*开会员，本书免费读.*|.*本书免费读.*|购买本章.*/).exists()) {
            setPushLog("会员内容停止阅读！")
            break
        }

        // 关闭内容更新提示
        //onClick(text("确认"), "确认更新内容")
        whileonClick(text("确认"), "确认更新内容");

        // 关闭继续阅读对话框
        // onClick(text("继续阅读"), "继续阅读", 0, 1000)
        // onClick(desc("继续阅读"), "继续阅读2", 0, 1000)
        whileonClick(text("继续阅读"), "继续阅读", 0, 1000)
        whileonClick(desc("继续阅读"), "继续阅读2", 0, 1000)

        // 判断是否为指定应用
        if (currentPackage() != app.getPackageName("QQ阅读")) {
            setPushLog("启动QQ阅读")
            app.launchApp("QQ阅读")
            sleep(5000)
        }

        // 判断是否在自动阅读状态
        if (!textContains("自动阅读中").exists()) {
            setPushLog("重新尝试开启自动阅读~")
            autoRead()
        }

        // 模拟人工操作
        if (textContains("自动阅读中").exists() && !random(0, 4)) {
            setPushLog("模拟人工操作，退出自动阅读，休息5秒")
            back()
            sleep(5000)
            autoRead()
        }

        // 防止一直卡在暂停状态
        if (textContains("自动阅读中").exists() && text("设置").exists()) {
            setPushLog("继续阅读")
            click(device.width / 2, device.height * 0.1 * random(5, 7))
            sleep(2000)
        }

        // 关闭弹窗 返回阅读页
        let tryNum2 = 3
        while (currentPackage() == app.getPackageName("QQ阅读") && !textContains("自动阅读中").exists() && tryNum2--) {
            setPushLog("返回上级，关闭弹窗")
            back()
            sleep(3000)
        }

        // 勿进打赏页返回后，阅读页不滚动
        let flag = idContains("cl_root")
        obj = flag.findOnce()
        if (textContains("自动阅读中").exists() && obj) {
            setPushLog("检查页面是否没有滚动")
            let temp = obj.bounds().bottom
            sleep(1000)
            obj = flag.findOnce()
            if (temp == obj.bounds().bottom) {
                setPushLog("退出自动阅读，重新开启自动阅读")
                back()
                sleep(2000)
                autoRead()
            }
        }

        // // 阅读页不正确，结束当前阅读
        // if (currentPackage() == app.getPackageName("QQ阅读") && !id("root").exists()) {
        //     device.vibrate(500)
        //     setPushLog("阅读页不正确，结束当前阅读！")
        //     sleep(2000)
        //     break
        // }

        setPushLog("账号[" + account + "]，已阅读[" + readTimeCount + "]分钟)")
        sleep(readCyclic * 60 * 1000)
        // sleep(5000)

        // 增加阅读时长
        readTimeCount += readCyclic;
        StoreWH.setReadTimeCount(account, readTimeCount)
        let temp = new Date().toLocaleDateString()
        StoreWH.setReadDate(account, temp)
        log("记录账号:" + account + "，今日阅读时长：" + StoreWH.getReadTimeCount(account))
        log("记录账号:" + account + "，阅读日期：" + StoreWH.getReadDate(account))
    }
}

// 日志推送
function setPushLog(msg) {
    toastLog(msg)
    StoreWH.setPushLog(msg)
    StoreWH.setLogBookID(bookID)
}

// 遍历出书名
function getBookNames(books) {
    names = []
    for (let i = 0; i < books.length; i++) {
        names.push(books[i].book_title)
    }
    return names
}


//======================================================================
main()
function main() {
    //等待开启无障碍服务
    auto.waitFor()

    // 获取设备id
    deviceID = StoreWH.getDeviceID()
    if (!deviceID || deviceID.length == 0 || deviceID == "0") {
        toastLog("请先配置设备id，再执行任务！")
        return
    }
    log("设备ID：[" + deviceID + "]")

    // 获取最大阅读时长
    maxReadTime = StoreWH.getMaxReadTime()
    log("最大阅读时长：" + maxReadTime)

    // 获取已完成账号列表
    CAccounts = StoreWH.getCAccounts()
    // CAccounts = ['321900230']
    log("已完成账号：[" + CAccounts + "]")

    // 获取阅文账号
    let temp = StoreWH.getYWAccounts()
    // let temp = [{ "account": "17165964781", "password": "lq520414" }]
    // let temp = []
    if (temp.length > 0) {
        // 排除已完成阅文账号
        ywAccounts = getOnlyOne(temp, CAccounts)
        log("阅文账号：" + JSON.stringify(ywAccounts))
    }


    dotask()

}



function dotask() {
    while (true) {
        // 遍历账号执行任务
        let tryNum = 10
        while (tryNum--) {
            // 全部账号任务完成
            if (isTaskAllFinish) break

            // 获取书籍列表
            tBooks = StoreWH.getBooks()
            // tBooks = [
            //     { book_id: 1, book_title: '皇帝排位赛' },
            //     { book_id: 2, book_title: '佛法满级' },
            //     { book_id: 3, book_title: '苍生圣父' }
            //]
            log("指定阅读书籍：" + JSON.stringify(tBooks))

            // 切换账号
            if (!switchAccount()) {
                // dialogs.alert("切换账号失败，请检查后重试！")
                toastLog("切换账号失败，跳过账号：" + account)
                continue
            }

            // 账号数据初始化
            let temp = new Date().toLocaleDateString()
            if (StoreWH.getReadDate(account) != temp) {
                toastLog("账号数据初始化")
                readTimeCount = 0
                StoreWH.setReadTimeCount(account, 0)
            } else {
                readTimeCount = StoreWH.getReadTimeCount(account)
            }
            log("账号：" + account + "，今日阅读时长：" + readTimeCount)

            // // 判断是不是有指定书籍
            // if (tBooks.length > 0) {
            //     //书架任务
            //     sjTask()
            // }

            // // 判断是不是有指定书籍
            // if (tBooks.length > 0) {
            //     //强推任务
            //     bzqtTask()
            // }

            if (tBooks.length > 0) {
                if (!sjTaskisok) {
                    sjTask();
                }
                if (!bzqtTaskisok) {
                    bzqtTask();
                }
            }

            //所有任务做完上报服务器停止当前账号（跳出循环）：
            // 修改设备状态
            if (bzqtTaskisok && sjTaskisok) {
                //数据重置
                resetData()
                // 增加已完成账号
                CAccounts.push(account)
                StoreWH.setCAccounts(CAccounts)

                HttpWH.stopStatus(deviceID)
                    .then((res) => {
                        // log(res.data)
                        if (res.data.status == 200) {
                            // 设备暂停状态修改成功
                            toastLog(res.data.msg)
                        } else {
                            toastLog(res.data.msg ? res.data.msg : "请求出错啦！")
                        }
                    })
                    .catch((e) => {
                        toastLog(e);
                    })

                toastLog("全部任务已完成！")
                home()
                sleep(5000);

                break;//跳出循环下一个账号做任务
            }
        }
    }








}